editor fully connected to outside world

editor/src/Elmz/Json/Request.elm

@@ -23,6 +23,9 @@ type Status e = Inactive | Waiting | Failed e
 post : Host -> Path -> Encoder a -> Decoder b -> Request a b
 post host path e d = Request (jsonPost e host path) d
 
+contramap : (a0 -> a) -> Request a b -> Request a0 b
+contramap f r = { r | encoder <- r.encoder << f }
+
 map : (b -> c) -> Request a b -> Request a c
 map f r = { r | decoder <- Decoder.map f r.decoder }
 

editor/src/Unison/Editor.elm

@@ -2,6 +2,7 @@ module Unison.Editor where
 
 import Debug
 import Execute
+import Elmz.Json.Request as JR
 import Elmz.Layout (Containment(Inside,Outside), Layout, Pt, Region)
 import Elmz.Layout as Layout
 import Elmz.Moore (Moore(..))
@@ -15,6 +16,7 @@ import Graphics.Input.Field as Field
 import Maybe
 import Mouse
 import Keyboard
+import Result
 import Signal
 import Unison.Action as Action
 import Unison.Explorer as Explorer
@@ -195,16 +197,65 @@ main =
   let
     host = "http://localhost:8080"
     (offsetX, offsetY) = (10, 10)
-    offsetMouse (x,y) = (x-offsetX, y-offsetY)
+    offsetMouse (x,y) = (x - offsetX, y - offsetY)
     searchbox = Signal.channel Field.noContent
     merge = Signal.merge
 
     reqChan : Signal.Channel (Maybe Request)
     reqChan = Signal.channel Nothing
 
+  --| Declare Term
     responses : Signal (Maybe Event)
-    responses = Signal.subscribe reqChan
-             |> Debug.crash "todo"
+    responses =
+      let
+        reqs = Signal.subscribe reqChan
+
+        evaluations =
+          let
+            match r = case r of
+              Just (Evaluations es) -> Just es
+              _ -> Nothing
+          in JR.send (Node.evaluateTerms host `JR.to` EvaluationResults) [] (Signal.map match reqs) |> Signal.map raise
+
+        edits =
+          let
+            z = ([], [], Action.Noop, Term.Blank) -- bogus initial edit
+            match r = case r of
+              Just (EditRequest focus action) ->
+                Just (focus.pathToClosedSubterm, focus.pathFromClosedSubterm, action, focus.closedSubterm)
+              _ -> Nothing
+          in JR.send (Node.editTerm host `JR.to` Replace) z (Signal.map match reqs) |> Signal.map raise
+
+        localInfos =
+          let
+            match r = case r of
+              Just (ExplorerRequest (TermExplorer.LocalInfo focus)) -> Just (focus.closedSubterm, focus.pathFromClosedSubterm)
+              _ -> Nothing
+          in JR.send (Node.localInfo host `JR.to` LocalInfoResults) (Term.Blank, []) (Signal.map match reqs) |> Signal.map raise
+
+        metadatas =
+          let
+            match r = case r of
+              Just (Metadatas refs) -> Just refs
+              _ -> Nothing
+          in JR.send (Node.metadatas host `JR.to` MetadataResults) [] (Signal.map match reqs) |> Signal.map raise
+
+        searches =
+          let
+            z = (Term.Blank, [], 1, "@#$@#", Nothing) -- bogus initial search
+            match r = case r of
+              Just (ExplorerRequest (TermExplorer.Search args)) -> Just args
+              _ -> Nothing
+          in JR.send (Node.search host `JR.to` SearchResults) z (Signal.map match reqs)
+             |> Signal.map raise
+
+        raise : Result (JR.Status String) Event -> Maybe Event
+        raise r = case r of
+          Result.Err _ -> Nothing -- todo, pass this along somehow
+          Result.Ok e -> Just e
+
+      in
+        evaluations `merge` edits `merge` localInfos `merge` metadatas `merge` searches
 
     actions : Signal (Maybe Event)
     actions =

editor/src/Unison/Node.elm

@@ -53,20 +53,22 @@ dependents host = Request.post host "dependents"
   (Encoder.tuple2 (Encoder.optional (Encoder.list Reference.encode)) Reference.encode)
   (Decoder.list Reference.decode)
 
-editTerm : Host -> Request (Path, Path, Action, Term) (Path,Term,Term)
+type alias Replacement = { path : Path, old : Term, new : Term }
+
+editTerm : Host -> Request (Path, Path, Action, Term) Replacement
 editTerm host = Request.post host "edit-term"
   (Encoder.tuple4 Path.encodePath Path.encodePath A.encode E.encodeTerm)
-  (Decoder.tuple3 Path.decodePath E.decodeTerm E.decodeTerm)
+  (Decoder.product3 Replacement Path.decodePath E.decodeTerm E.decodeTerm)
 
 editType : Host -> Request (Path, Action, Type) Type
 editType host = Request.post host "edit-type"
   (Encoder.tuple3 Path.encodePath A.encode T.encodeType)
   T.decodeType
 
-evaluateTerms : Host -> Request (List (Path, Term)) (List (Path,Term,Term))
+evaluateTerms : Host -> Request (List (Path, Term)) (List Replacement)
 evaluateTerms host = Request.post host "evaluate-terms"
   (Encoder.list (Encoder.tuple2 Path.encodePath E.encodeTerm))
-  (Decoder.list (Decoder.tuple3 Path.decodePath E.decodeTerm E.decodeTerm))
+  (Decoder.list (Decoder.product3 Replacement Path.decodePath E.decodeTerm E.decodeTerm))
 
 type alias LocalInfo =
   { current : Type
@@ -85,10 +87,10 @@ localInfo host = Request.post host "local-info"
     (Decoder.list Decoder.int)
     (Decoder.list E.decodeTerm))
 
-metadatas : Host -> Request (List Reference) (M.Dict Reference.Key Metadata)
+metadatas : Host -> Request (List Reference) (List (Reference.Key, Metadata))
 metadatas host = Request.post host "metadatas"
   (Encoder.list Reference.encode)
-  (Reference.decodeMap MD.decodeMetadata)
+  (Reference.decodeAssociationList MD.decodeMetadata)
 
 type alias SearchResults =
   { query : Query

editor/src/Unison/Reference.elm

@@ -28,7 +28,6 @@ encode r = case r of
   Builtin b -> Encoder.tag' "Builtin" Encoder.string b
   Derived h -> Encoder.tag' "Derived" H.encode h
 
-
 decodeAssociationList : Decoder v -> Decoder (List (Key, v))
 decodeAssociationList v =
   Decoder.list (Decoder.tuple2 decode v)