Merge branch 'conjure-eval-update'

Author: Olical

fnl/conjure/buffer.fnl

@@ -1,53 +1,54 @@
-(local {: autoload} (require :conjure.nfnl.module))
-(local nvim (autoload :conjure.aniseed.nvim))
+(local {: autoload : define} (require :conjure.nfnl.module))
 (local core (autoload :conjure.nfnl.core))
 (local text (autoload :conjure.text))
 
-(fn unlist [buf]
+(local M (define :conjure.buffer))
+
+(fn M.unlist [buf]
   "The buflisted attribute is reset when a new window is opened. Since the
   buffer upsert is decoupled from the window we have to run this whenever we
   split the buffer into some new window."
-  (nvim.buf_set_option buf :buflisted false))
+  (vim.api.nvim_buf_set_option buf :buflisted false))
 
-(fn resolve [buf-name]
-  (nvim.buf_get_name (nvim.fn.bufnr buf-name)))
+(fn M.resolve [buf-name]
+  (vim.api.nvim_buf_get_name (vim.fn.bufnr buf-name)))
 
-(fn upsert-hidden [buf-name new-buf-fn]
-  (let [(ok? buf) (pcall nvim.fn.bufnr buf-name)
-        loaded? (and ok? (nvim.buf_is_loaded buf))]
+(fn M.upsert-hidden [buf-name new-buf-fn]
+  (let [(ok? buf) (pcall vim.fn.bufnr buf-name)
+        loaded? (and ok? (vim.api.nvim_buf_is_loaded buf))]
 
     ;; This state happens when the user unloads the buffer somehow.
     ;; It still exists but is in a bad state, we delete and start over.
     (when (and (not= -1 buf) (not loaded?))
-      (nvim.buf_delete buf {}))
+      (vim.api.nvim_buf_delete buf {}))
 
     (if (or (= -1 buf) (not loaded?))
       (let [buf (if loaded?
                   buf
-                  (let [buf (nvim.fn.bufadd buf-name)]
-                    (nvim.fn.bufload buf)
+                  (let [buf (vim.fn.bufadd buf-name)]
+                    (vim.fn.bufload buf)
                     buf))]
-        (nvim.buf_set_option buf :buftype :nofile)
-        (nvim.buf_set_option buf :bufhidden :hide)
-        (nvim.buf_set_option buf :swapfile false)
-        (unlist buf)
+        (vim.api.nvim_buf_set_option buf :buftype :nofile)
+        (vim.api.nvim_buf_set_option buf :bufhidden :hide)
+        (vim.api.nvim_buf_set_option buf :swapfile false)
+        (M.unlist buf)
         (when new-buf-fn
           (new-buf-fn buf))
         buf)
       buf)))
 
-(fn empty? [buf]
-  (and (<= (nvim.buf_line_count buf) 1)
-       (= 0 (core.count (core.first (nvim.buf_get_lines buf 0 -1 false))))))
+(fn M.empty? [buf]
+  (and (<= (vim.api.nvim_buf_line_count buf) 1)
+       (= 0 (core.count (core.first (vim.api.nvim_buf_get_lines buf 0 -1 false))))))
 
-(fn replace-range [buf range s]
+(fn M.replace-range [buf range s]
   (let [start-line (core.dec (core.get-in range [:start 1]))
         end-line (core.get-in range [:end 1])
         start-char (core.get-in range [:start 2])
         end-char (core.get-in range [:end 2])
 
         new-lines (text.split-lines s)
-        old-lines (nvim.buf_get_lines buf start-line end-line false)
+        old-lines (vim.api.nvim_buf_get_lines buf start-line end-line false)
 
         head (string.sub (core.first old-lines) 1 start-char)
         tail (string.sub (core.last old-lines) (+ end-char 2))]
@@ -60,15 +61,15 @@
       new-lines (core.count new-lines)
       (fn [l] (.. l tail)))
 
-    (nvim.buf_set_lines buf start-line end-line false new-lines)))
+    (vim.api.nvim_buf_set_lines buf start-line end-line false new-lines)))
 
-(fn append-prefixed-line [buf [tl tc] prefix body]
+(fn M.append-prefixed-line [buf [tl tc] prefix body]
   "Appends a string to the end of the current line, or the one below this one
   if there's already the same suffix on the end. If there's already a matching
   suffix on the end of this line and the one below, it will insert another
   below that last one and so on."
   (let [tl (core.dec tl)
-        [head-line & lines] (nvim.buf_get_lines buf tl -1 false)
+        [head-line & lines] (vim.api.nvim_buf_get_lines buf tl -1 false)
         to-append (text.prefixed-lines body prefix {})]
     (if (head-line:find prefix tc)
       (let [[new-tl lines]
@@ -82,8 +83,8 @@
                    (core.take-while core.identity)
                    (core.last))
               [tl (core.concat [head-line] to-append)])]
-        (nvim.buf_set_lines buf new-tl (core.inc new-tl) false lines))
-      (nvim.buf_set_lines
+        (vim.api.nvim_buf_set_lines buf new-tl (core.inc new-tl) false lines))
+      (vim.api.nvim_buf_set_lines
         buf tl
         (core.inc tl)
         false
@@ -93,9 +94,4 @@
             [head-line]
             to-append))))))
 
-{: unlist
- : resolve
- : upsert-hidden
- : empty?
- : replace-range
- : append-prefixed-line}
+M

fnl/conjure/dynamic.fnl

@@ -1,47 +1,47 @@
-(local {: autoload} (require :conjure.nfnl.module))
-(local a (autoload :conjure.aniseed.core))
+(local {: autoload : define} (require :conjure.nfnl.module))
+(local core (autoload :conjure.nfnl.core))
+
+(local M (define :conjure.dynamic))
 
 (local get-stack-key :conjure.dynamic/get-stack)
 
 (fn assert-value-function! [value]
   (when (not= :function (type value))
     (error "conjure.dynamic values must always be wrapped in a function")))
 
-(fn new [base-value]
+(fn M.new [base-value]
   (assert-value-function! base-value)
-  (var stack [base-value])
-  (fn [x ...]
-    (if (= get-stack-key x) stack
-      ((a.last stack) x ...))))
+  (let [stack [base-value]]
+    (fn [x ...]
+      (if (= get-stack-key x)
+        stack
+        ((core.last stack) x ...)))))
 
 (fn run-binds! [f binds]
-  (a.map-indexed
+  (core.map-indexed
     (fn [[dyn new-value]]
       (assert-value-function! new-value)
       (f (dyn get-stack-key) new-value))
     binds))
 
-(fn bind [binds f ...]
+(fn M.bind [binds f ...]
   (run-binds! table.insert binds)
   (let [(ok? result) (pcall f ...)]
     (run-binds! #(table.remove $1) binds)
     (if ok?
       result
       (error result))))
 
-(fn set! [dyn new-value]
+(fn M.set! [dyn new-value]
   (assert-value-function! new-value)
   (let [stack (dyn get-stack-key)
-        depth (a.count stack)]
-    (a.assoc stack depth new-value))
+        depth (core.count stack)]
+    (core.assoc stack depth new-value))
   nil)
 
-(fn set-root! [dyn new-value]
+(fn M.set-root! [dyn new-value]
   (assert-value-function! new-value)
-  (a.assoc (dyn get-stack-key) 1 new-value)
+  (core.assoc (dyn get-stack-key) 1 new-value)
   nil)
 
-{: new
- : bind
- : set!
- : set-root!}
+M