aboutsummaryrefslogtreecommitdiff
path: root/stdlib
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--stdlib/source/lux/concurrency/actor.lux14
-rw-r--r--stdlib/source/lux/concurrency/promise.lux98
-rw-r--r--stdlib/source/lux/concurrency/stm.lux192
-rw-r--r--stdlib/source/lux/data/color.lux12
-rw-r--r--stdlib/source/lux/data/lazy.lux18
-rw-r--r--stdlib/source/lux/data/tainted.lux4
-rw-r--r--stdlib/source/lux/time/duration.lux16
-rw-r--r--stdlib/source/lux/time/instant.lux18
-rw-r--r--stdlib/source/lux/type/abstract.lux14
-rw-r--r--stdlib/source/lux/type/unit.lux4
-rw-r--r--stdlib/source/lux/world/net/tcp.jvm.lux12
-rw-r--r--stdlib/source/lux/world/net/udp.jvm.lux10
12 files changed, 217 insertions, 195 deletions
diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux
index 3a032e00f..4c98d10e4 100644
--- a/stdlib/source/lux/concurrency/actor.lux
+++ b/stdlib/source/lux/concurrency/actor.lux
@@ -45,8 +45,8 @@
## TODO: Delete after new-luxc becomes the new standard compiler.
(def: (actor mailbox obituary)
(All [s] (-> (Atom <Mailbox>) (Promise <Obituary>) (Actor s)))
- (@abstract {#mailbox mailbox
- #obituary obituary}))
+ (@abstraction {#mailbox mailbox
+ #obituary obituary}))
(type: #export (Message s)
<Message>)
@@ -66,7 +66,7 @@
self (actor (atom (promise #.None))
(promise #.None))
process (loop [state init
- |mailbox| (io.run (atom.read (get@ #mailbox (@repr self))))]
+ |mailbox| (io.run (atom.read (get@ #mailbox (@representation self))))]
(do promise.Monad<Promise>
[[head tail] |mailbox|
?state' (handle head state self)]
@@ -75,7 +75,7 @@
(do @
[_ (end error state)]
(exec (io.run (promise.resolve [error state (#.Cons head (obituary tail))]
- (get@ #obituary (@repr self))))
+ (get@ #obituary (@representation self))))
(wrap [])))
(#e.Success state')
@@ -84,7 +84,7 @@
(def: #export (alive? actor)
(All [s] (-> (Actor s) Bool))
- (case (promise.poll (get@ #obituary (@repr actor)))
+ (case (promise.poll (get@ #obituary (@representation actor)))
#.None
true
@@ -97,7 +97,7 @@
(if (alive? actor)
(let [entry [message (promise #.None)]]
(do Monad<IO>
- [|mailbox| (atom.read (get@ #mailbox (@repr actor)))]
+ [|mailbox| (atom.read (get@ #mailbox (@representation actor)))]
(loop [|mailbox| |mailbox|]
(case (promise.poll |mailbox|)
#.None
@@ -105,7 +105,7 @@
[resolved? (promise.resolve entry |mailbox|)]
(if resolved?
(do @
- [_ (atom.write (product.right entry) (get@ #mailbox (@repr actor)))]
+ [_ (atom.write (product.right entry) (get@ #mailbox (@representation actor)))]
(wrap true))
(recur |mailbox|)))
diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux
index 429a11931..e1084d9a9 100644
--- a/stdlib/source/lux/concurrency/promise.lux
+++ b/stdlib/source/lux/concurrency/promise.lux
@@ -6,26 +6,61 @@
[applicative #+ Applicative]
[monad #+ do Monad])
(data [product])
- (concurrency [atom #+ Atom atom])))
+ (concurrency [atom #+ Atom atom])
+ (type abstract)))
(def: #export concurrency-level
Nat
("lux process concurrency-level"))
-(type: #export (Promise a)
+(abstract: #export (Promise a)
{#.doc "Represents values produced by asynchronous computations (unlike IO, which is synchronous)."}
- (Atom [(Maybe a) (List (-> a (IO Top)))]))
-
-(def: #export (promise ?value)
- (All [a] (-> (Maybe a) (Promise a)))
- (atom [?value (list)]))
-
-(def: #export (poll promise)
- {#.doc "Polls a promise's value."}
- (All [a] (-> (Promise a) (Maybe a)))
- (|> (atom.read promise)
- io.run
- product.left))
+ (Atom [(Maybe a) (List (-> a (IO Top)))])
+
+ (def: #export (promise ?value)
+ (All [a] (-> (Maybe a) (Promise a)))
+ (@abstraction (atom [?value (list)])))
+
+ (def: #export (poll (^@representation promise))
+ {#.doc "Polls a promise's value."}
+ (All [a] (-> (Promise a) (Maybe a)))
+ (|> (atom.read promise)
+ io.run
+ product.left))
+
+ (def: #export (resolve value (^@representation promise))
+ {#.doc "Sets an promise's value if it has not been done yet."}
+ (All [a] (-> a (Promise a) (IO Bool)))
+ (do io.Monad<IO>
+ [(^@ old [_value _observers]) (atom.read promise)]
+ (case _value
+ (#.Some _)
+ (wrap false)
+
+ #.None
+ (do @
+ [#let [new [(#.Some value) #.None]]
+ succeeded? (atom.compare-and-swap old new promise)]
+ (if succeeded?
+ (do @
+ [_ (monad.map @ (function [f] (f value))
+ _observers)]
+ (wrap true))
+ (resolve value (@abstraction promise)))))))
+
+ (def: #export (await f (^@representation promise))
+ (All [a] (-> (-> a (IO Top)) (Promise a) Top))
+ (let [(^@ old [_value _observers]) (io.run (atom.read promise))]
+ (case _value
+ (#.Some value)
+ (io.run (f value))
+
+ #.None
+ (let [new [_value (#.Cons f _observers)]]
+ (if (io.run (atom.compare-and-swap old new promise))
+ []
+ (await f (@abstraction promise)))))))
+ )
(def: #export (resolved? promise)
{#.doc "Checks whether a promise's value has already been resolved."}
@@ -37,39 +72,6 @@
(#.Some _)
true))
-(def: #export (resolve value promise)
- {#.doc "Sets an promise's value if it has not been done yet."}
- (All [a] (-> a (Promise a) (IO Bool)))
- (do io.Monad<IO>
- [(^@ old [_value _observers]) (atom.read promise)]
- (case _value
- (#.Some _)
- (wrap false)
-
- #.None
- (do @
- [#let [new [(#.Some value) _observers]]
- succeeded? (atom.compare-and-swap old new promise)]
- (if succeeded?
- (do @
- [_ (monad.map @ (function [f] (f value))
- _observers)]
- (wrap true))
- (resolve value promise))))))
-
-(def: #export (await f promise)
- (All [a] (-> (-> a (IO Top)) (Promise a) Top))
- (let [(^@ old [_value _observers]) (io.run (atom.read promise))]
- (case _value
- (#.Some value)
- (io.run (f value))
-
- #.None
- (let [new [_value (#.Cons f _observers)]]
- (if (io.run (atom.compare-and-swap old new promise))
- []
- (await f promise))))))
-
(struct: #export _ (Functor Promise)
(def: (map f fa)
(let [fb (promise #.None)]
@@ -81,7 +83,7 @@
(def: functor Functor<Promise>)
(def: (wrap a)
- (atom [(#.Some a) (list)]))
+ (promise (#.Some a)))
(def: (apply ff fa)
(let [fb (promise #.None)]
diff --git a/stdlib/source/lux/concurrency/stm.lux b/stdlib/source/lux/concurrency/stm.lux
index 09daa5e2d..9b1cabe01 100644
--- a/stdlib/source/lux/concurrency/stm.lux
+++ b/stdlib/source/lux/concurrency/stm.lux
@@ -3,7 +3,7 @@
(lux (control [functor #+ Functor]
[applicative #+ Applicative]
[monad #+ do Monad])
- [io #- run]
+ [io #+ IO io]
(data [product]
[maybe]
[number "nat/" Codec<Text,Nat>]
@@ -11,13 +11,75 @@
(coll [list "list/" Functor<List> Fold<List>]
[dict #+ Dict]))
(concurrency [atom #+ Atom atom]
- ["P" promise]
+ [promise #+ Promise promise]
[frp "frp/" Functor<Channel>])
- ))
+ (type abstract)))
-(type: #export (Var a)
+(abstract: #export (Var a)
{#.doc "A mutable cell containing a value, and observers that will be alerted of any change to it."}
- (Atom [a (Dict Text (-> a (IO Unit)))]))
+ (Atom [a (Dict Text (-> a (IO Unit)))])
+
+ (def: #export (var value)
+ {#.doc "Creates a new STM var, with a default value."}
+ (All [a] (-> a (Var a)))
+ (@abstraction (atom.atom [value (dict.new text.Hash<Text>)])))
+
+ (def: read!!
+ (All [a] (-> (Var a) a))
+ (|>> @representation atom.read io.run product.left))
+
+ (def: #export (read! (^@representation var))
+ {#.doc "Reads var immediately, without going through a transaction."}
+ (All [a] (-> (Var a) (IO a)))
+ (|> var
+ atom.read
+ (:: io.Functor<IO> map product.left)))
+
+ (def: (write! new-value (^@representation var))
+ (All [a] (-> a (Var a) (IO Unit)))
+ (do io.Monad<IO>
+ [(^@ old [_value _observers]) (atom.read var)
+ succeeded? (atom.compare-and-swap old [new-value _observers] var)]
+ (if succeeded?
+ (do @
+ [_ (|> _observers
+ dict.values
+ (monad.map @ (function [f] (f new-value))))]
+ (wrap []))
+ (write! new-value (@abstraction var)))))
+
+ (def: #export (follow (^@representation target))
+ {#.doc "Creates a channel that will receive all changes to the value of the given var."}
+ (All [a] (-> (Var a) (IO (frp.Channel a))))
+ (let [head (: (frp.Channel ($ +0)) (frp.channel))
+ ## head (frp.channel)
+ channel-var (var head)
+ observer (function [label value]
+ (case (io.run (|> channel-var read!! (frp.write value)))
+ #.None
+ ## By closing the output Channel, the
+ ## observer becomes obsolete.
+ (atom.update (function [[value observers]]
+ [value (dict.remove label observers)])
+ target)
+
+ (#.Some tail')
+ (write! tail' channel-var)))]
+ (do io.Monad<IO>
+ [_ (atom.update (function [[value observers]]
+ (let [label (nat/encode (list/fold (function [key base]
+ (case (nat/decode key)
+ (#.Left _)
+ base
+
+ (#.Right key-num)
+ (n/max key-num base)))
+ +0
+ (dict.keys observers)))]
+ [value (dict.put label (observer label) observers)]))
+ target)]
+ (wrap head))))
+ )
(type: (Tx-Frame a)
{#var (Var a)
@@ -31,15 +93,6 @@
{#.doc "A computation which updates a transaction and produces a value."}
(-> Tx [Tx a]))
-(def: #export (var value)
- {#.doc "Creates a new STM var, with a default value."}
- (All [a] (-> a (Var a)))
- (atom.atom [value (dict.new text.Hash<Text>)]))
-
-(def: raw-read
- (All [a] (-> (Var a) a))
- (|>> atom.read io.run product.left))
-
(def: (find-var-value var tx)
(All [a] (-> (Var a) Tx (Maybe a)))
(|> tx
@@ -59,17 +112,10 @@
[tx value]
#.None
- (let [value (raw-read var)]
+ (let [value (read!! var)]
[(#.Cons [var value value] tx)
value]))))
-(def: #export (read! var)
- {#.doc "Reads var immediately, without going through a transaction."}
- (All [a] (-> (Var a) (IO a)))
- (|> var
- atom.read
- (:: Functor<IO> map product.left)))
-
(def: (update-tx-value var value tx)
(All [a] (-> (Var a) a Tx Tx))
(case tx
@@ -99,54 +145,9 @@
[]]
#.None
- [(#.Cons [var (raw-read var) value] tx)
+ [(#.Cons [var (read!! var) value] tx)
[]])))
-(def: (write! new-value var)
- (All [a] (-> a (Var a) (IO Unit)))
- (do Monad<IO>
- [(^@ old [_value _observers]) (atom.read var)
- succeeded? (atom.compare-and-swap old [new-value _observers] var)]
- (if succeeded?
- (do @
- [_ (|> _observers
- dict.values
- (monad.map @ (function [f] (f new-value))))]
- (wrap []))
- (write! new-value var))))
-
-(def: #export (follow target)
- {#.doc "Creates a channel that will receive all changes to the value of the given var."}
- (All [a] (-> (Var a) (IO (frp.Channel a))))
- (let [head (: (frp.Channel ($ +0)) (frp.channel))
- ## head (frp.channel)
- channel-var (var head)
- observer (function [label value]
- (case (io.run (|> channel-var raw-read (frp.write value)))
- #.None
- ## By closing the output Channel, the
- ## observer becomes obsolete.
- (atom.update (function [[value observers]]
- [value (dict.remove label observers)])
- target)
-
- (#.Some tail')
- (write! tail' channel-var)))]
- (do Monad<IO>
- [_ (atom.update (function [[value observers]]
- (let [label (nat/encode (list/fold (function [key base]
- (case (nat/decode key)
- (#.Left _)
- base
-
- (#.Right key-num)
- (n/max key-num base)))
- +0
- (dict.keys observers)))]
- [value (dict.put label (observer label) observers)]))
- target)]
- (wrap head))))
-
(struct: #export _ (Functor STM)
(def: (map f fa)
(function [tx]
@@ -185,7 +186,7 @@
(def: (can-commit? tx)
(-> Tx Bool)
(list.every? (function [[_var _original _current]]
- (is _original (raw-read _var)))
+ (is _original (read!! _var)))
tx))
(def: (commit-var! [_var _original _current])
@@ -196,44 +197,53 @@
(def: fresh-tx Tx (list))
+(type: Commit (Ex [a] [(STM a) (Promise a)]))
+
(def: pending-commits
- (Var (Ex [a] [(STM a) (P.Promise a)]))
- (var (:!! [])))
+ (Atom (Rec Commits (Promise [Commit Commits])))
+ (atom (promise #.None)))
(def: commit-processor-flag
(Atom Bool)
(atom false))
+(def: (issue-commit commit)
+ (-> Commit (IO Unit))
+ (let [entry [commit (promise #.None)]]
+ (loop [|commits| (io.run (atom.read pending-commits))]
+ (case (promise.poll |commits|)
+ #.None
+ (do io.Monad<IO>
+ [resolved? (promise.resolve entry |commits|)]
+ (if resolved?
+ (atom.write (product.right entry) pending-commits)
+ (recur |commits|)))
+
+ (#.Some [head tail])
+ (recur tail)))))
+
(def: (process-commit [stm-proc output])
- (-> [(STM Unit) (P.Promise Unit)] Top)
+ (-> [(STM Unit) (Promise Unit)] Top)
(let [[finished-tx value] (stm-proc fresh-tx)]
(io.run (if (can-commit? finished-tx)
(exec (list/map commit-var! finished-tx)
- (P.resolve value output))
- (write! [stm-proc output] pending-commits)))))
+ (promise.resolve value output))
+ (issue-commit [stm-proc output])))))
(def: init-processor!
(IO Unit)
- (do Monad<IO>
+ (do io.Monad<IO>
[flag (atom.read commit-processor-flag)]
(if flag
(wrap [])
(do @
[was-first? (atom.compare-and-swap flag true commit-processor-flag)]
(if was-first?
- (do Monad<IO>
- [inputs (follow pending-commits)]
- (exec (|> inputs
- (:! (frp.Channel [(STM Unit) (P.Promise Unit)]))
- (P.await (function recur [?inputs]
- (io (case ?inputs
- #.None
- []
-
- (#.Some [head tail])
- (exec (process-commit head)
- (P.await recur tail)))))))
- (wrap [])))
+ (exec (|> (io.run (atom.read pending-commits))
+ (promise.await (function recur [[head tail]]
+ (io (exec (process-commit (:! [(STM Unit) (Promise Unit)] head))
+ (promise.await recur tail))))))
+ (wrap []))
(wrap [])))
)))
@@ -243,8 +253,8 @@
Note that a transaction may be re-run an indeterminate number of times if other transactions involving the same variables successfully commit first.
For this reason, it's important to note that transactions must be free from side-effects, such as I/O."}
- (All [a] (-> (STM a) (P.Promise a)))
- (let [output (P.promise #.None)]
+ (All [a] (-> (STM a) (Promise a)))
+ (let [output (promise #.None)]
(exec (io.run init-processor!)
- (io.run (write! [stm-proc output] pending-commits))
+ (io.run (issue-commit [stm-proc output]))
output)))
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index 2a23c5406..899531a79 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -28,18 +28,18 @@
(def: #export (color [red green blue])
(-> [Nat Nat Nat] Color)
- (@abstract [(n/% rgb red)
- (n/% rgb green)
- (n/% rgb blue)]))
+ (@abstraction [(n/% rgb red)
+ (n/% rgb green)
+ (n/% rgb blue)]))
(def: #export unpack
(-> Color [Nat Nat Nat])
- (|>> @repr))
+ (|>> @representation))
(struct: #export _ (eq.Eq Color)
(def: (= reference sample)
- (let [[rr rg rb] (@repr reference)
- [sr sg sb] (@repr sample)]
+ (let [[rr rg rb] (@representation reference)
+ [sr sg sb] (@representation sample)]
(and (n/= rr sr)
(n/= rg sg)
(n/= rb sb)))))
diff --git a/stdlib/source/lux/data/lazy.lux b/stdlib/source/lux/data/lazy.lux
index 154a3018b..7d5fbb417 100644
--- a/stdlib/source/lux/data/lazy.lux
+++ b/stdlib/source/lux/data/lazy.lux
@@ -15,19 +15,19 @@
(def: (freeze' generator)
(All [a] (-> (-> [] a) (Lazy a)))
(let [cache (atom.atom #.None)]
- (@abstract (function [_]
- (case (io.run (atom.read cache))
- (#.Some value)
- value
+ (@abstraction (function [_]
+ (case (io.run (atom.read cache))
+ (#.Some value)
+ value
- _
- (let [value (generator [])]
- (exec (io.run (atom.compare-and-swap _ (#.Some value) cache))
- value)))))))
+ _
+ (let [value (generator [])]
+ (exec (io.run (atom.compare-and-swap _ (#.Some value) cache))
+ value)))))))
(def: #export (thaw l-value)
(All [a] (-> (Lazy a) a))
- ((@repr l-value) [])))
+ ((@representation l-value) [])))
(syntax: #export (freeze expr)
(with-gensyms [g!_]
diff --git a/stdlib/source/lux/data/tainted.lux b/stdlib/source/lux/data/tainted.lux
index 2e15ba974..d1ecbd213 100644
--- a/stdlib/source/lux/data/tainted.lux
+++ b/stdlib/source/lux/data/tainted.lux
@@ -8,11 +8,11 @@
(def: #export taint
(All [a] (-> a (Tainted a)))
- (|>> @abstract))
+ (|>> @abstraction))
(def: #export trust
(All [a] (-> (Tainted a) a))
- (|>> @repr)))
+ (|>> @representation)))
(def: #export (validate pred tainted)
(All [a] (-> (-> a Bool) (Tainted a) (Maybe a)))
diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux
index f2eb63863..c17c5693f 100644
--- a/stdlib/source/lux/time/duration.lux
+++ b/stdlib/source/lux/time/duration.lux
@@ -17,16 +17,16 @@
(def: #export from-millis
(-> Int Duration)
- (|>> @abstract))
+ (|>> @abstraction))
(def: #export to-millis
(-> Duration Int)
- (|>> @repr))
+ (|>> @representation))
(do-template [<name> <op>]
[(def: #export (<name> param subject)
(-> Duration Duration Duration)
- (@abstract (<op> (@repr param) (@repr subject))))]
+ (@abstraction (<op> (@representation param) (@representation subject))))]
[merge i/+]
[frame i/%]
@@ -34,21 +34,21 @@
(def: #export (scale scalar duration)
(-> Int Duration Duration)
- (@abstract (i/* scalar (@repr duration))))
+ (@abstraction (i/* scalar (@representation duration))))
(def: #export (query param subject)
(-> Duration Duration Int)
- (i// (@repr param) (@repr subject)))
+ (i// (@representation param) (@representation subject)))
(struct: #export _ (Eq Duration)
(def: (= param subject)
- (i/= (@repr param) (@repr subject))))
+ (i/= (@representation param) (@representation subject))))
(struct: #export _ (Order Duration)
(def: eq Eq<Duration>)
(do-template [<name> <op>]
[(def: (<name> param subject)
- (<op> (@repr param) (@repr subject)))]
+ (<op> (@representation param) (@representation subject)))]
[< i/<]
[<= i/<=]
@@ -59,7 +59,7 @@
(do-template [<name> <op>]
[(def: #export (<name> duration)
(-> Duration Bool)
- (<op> 0 (@repr duration)))]
+ (<op> 0 (@representation duration)))]
[positive? i/>]
[negative? i/<]
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index 381820058..334b05115 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -24,37 +24,37 @@
(def: #export from-millis
(-> Int Instant)
- (|>> @abstract))
+ (|>> @abstraction))
(def: #export to-millis
(-> Instant Int)
- (|>> @repr))
+ (|>> @representation))
(def: #export (span from to)
(-> Instant Instant duration.Duration)
- (duration.from-millis (i/- (@repr from) (@repr to))))
+ (duration.from-millis (i/- (@representation from) (@representation to))))
(def: #export (shift duration instant)
(-> duration.Duration Instant Instant)
- (@abstract (i/+ (duration.to-millis duration) (@repr instant))))
+ (@abstraction (i/+ (duration.to-millis duration) (@representation instant))))
(def: #export (relative instant)
(-> Instant duration.Duration)
- (|> instant @repr duration.from-millis))
+ (|> instant @representation duration.from-millis))
(def: #export (absolute offset)
(-> duration.Duration Instant)
- (|> offset duration.to-millis @abstract))
+ (|> offset duration.to-millis @abstraction))
(struct: #export _ (Eq Instant)
(def: (= param subject)
- (:: number.Eq<Int> = (@repr param) (@repr subject))))
+ (:: number.Eq<Int> = (@representation param) (@representation subject))))
(struct: #export _ (Order Instant)
(def: eq Eq<Instant>)
(do-template [<name>]
[(def: (<name> param subject)
- (:: number.Order<Int> <name> (@repr param) (@repr subject)))]
+ (:: number.Order<Int> <name> (@representation param) (@representation subject)))]
[<] [<=] [>] [>=]
))
@@ -63,7 +63,7 @@
(def: order Order<Instant>)
(do-template [<name>]
[(def: <name>
- (|>> @repr (:: number.Enum<Int> <name>) @abstract))]
+ (|>> @representation (:: number.Enum<Int> <name>) @abstraction))]
[succ] [pred]
))
diff --git a/stdlib/source/lux/type/abstract.lux b/stdlib/source/lux/type/abstract.lux
index 9a991a2a9..d3f3eb118 100644
--- a/stdlib/source/lux/type/abstract.lux
+++ b/stdlib/source/lux/type/abstract.lux
@@ -49,8 +49,8 @@
plist'
(#.Cons [k' v'] (remove k plist')))))
-(def: down-cast Text "@abstract")
-(def: up-cast Text "@repr")
+(def: down-cast Text "@abstraction")
+(def: up-cast Text "@representation")
(def: macro-anns Code (' {#.macro? true}))
(def: representation-name
@@ -164,3 +164,13 @@
(` ((~! install-casts) (~ (code.local-symbol name)) [(~+ type-varsC)]))
(list/compose primitives
(list (` ((~! un-install-casts)))))))))
+
+(syntax: #export (^@representation [name (s.form s.local-symbol)] body [branches (p.some s.any)])
+ (let [g!representation (code.local-symbol name)]
+ (do @
+ [current-module macro.current-module-name
+ #let [g!@representation (code.symbol [current-module "@representation"])]]
+ (wrap (list& g!representation
+ (` (.let [(~ g!representation) ((~ g!@representation) (~ g!representation))]
+ (~ body)))
+ branches)))))
diff --git a/stdlib/source/lux/type/unit.lux b/stdlib/source/lux/type/unit.lux
index c483ad71b..e8092a4e6 100644
--- a/stdlib/source/lux/type/unit.lux
+++ b/stdlib/source/lux/type/unit.lux
@@ -21,11 +21,11 @@
(def: #export in
(All [unit] (-> Int (Qty unit)))
- (|>> @abstract))
+ (|>> @abstraction))
(def: #export out
(All [unit] (-> (Qty unit) Int))
- (|>> @repr)))
+ (|>> @representation)))
(sig: #export (Scale s)
(: (All [u] (-> (Qty u) (Qty (s u))))
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index dfc27a0f2..fcd037578 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -42,7 +42,7 @@
#out OutputStream}
(def: #export (read data offset length self)
- (let [in (get@ #in (@repr self))]
+ (let [in (get@ #in (@representation self))]
(P.future
(do (e.ErrorT io.Monad<IO>)
[bytes-read (InputStream::read [data (nat-to-int offset) (nat-to-int length)]
@@ -50,7 +50,7 @@
(wrap (int-to-nat bytes-read))))))
(def: #export (write data offset length self)
- (let [out (get@ #out (@repr self))]
+ (let [out (get@ #out (@representation self))]
(P.future
(do (e.ErrorT io.Monad<IO>)
[_ (OutputStream::write [data (nat-to-int offset) (nat-to-int length)]
@@ -58,7 +58,7 @@
(Flushable::flush [] out)))))
(def: #export (close self)
- (let [(^open) (@repr self)]
+ (let [(^open) (@representation self)]
(P.future
(do (e.ErrorT io.Monad<IO>)
[_ (AutoCloseable::close [] in)
@@ -70,9 +70,9 @@
(do (e.ErrorT io.Monad<IO>)
[input (Socket::getInputStream [] socket)
output (Socket::getOutputStream [] socket)]
- (wrap (@abstract {#socket socket
- #in input
- #out output}))))
+ (wrap (@abstraction {#socket socket
+ #in input
+ #out output}))))
(def: #export (client address port)
(-> //.Address //.Port (T.Task TCP))
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index 468d3b2b9..caec294cd 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -59,7 +59,7 @@
(def: #export (read data offset length self)
(-> Blob Nat Nat UDP (T.Task [Nat //.Address //.Port]))
- (let [(^open) (@repr self)
+ (let [(^open) (@representation self)
packet (DatagramPacket::new|receive [data (nat-to-int offset) (nat-to-int length)])]
(P.future
(do (e.ErrorT io.Monad<IO>)
@@ -74,13 +74,13 @@
(P.future
(do (e.ErrorT io.Monad<IO>)
[address (resolve address)
- #let [(^open) (@repr self)]]
+ #let [(^open) (@representation self)]]
(DatagramSocket::send (DatagramPacket::new|send [data (nat-to-int offset) (nat-to-int length) address (nat-to-int port)])
socket))))
(def: #export (close self)
(-> UDP (T.Task Unit))
- (let [(^open) (@repr self)]
+ (let [(^open) (@representation self)]
(P.future
(AutoCloseable::close [] socket))))
@@ -89,12 +89,12 @@
(P.future
(do (e.ErrorT io.Monad<IO>)
[socket (DatagramSocket::new|client [])]
- (wrap (@abstract (#socket socket))))))
+ (wrap (@abstraction (#socket socket))))))
(def: #export (server port)
(-> //.Port (T.Task UDP))
(P.future
(do (e.ErrorT io.Monad<IO>)
[socket (DatagramSocket::new|server [(nat-to-int port)])]
- (wrap (@abstract (#socket socket))))))
+ (wrap (@abstraction (#socket socket))))))
)
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-28 09:47:18 +0000