extract more effects

Author: CrowdHailer

packages/touch_grass/src/touch_grass.gleam

@@ -1,13 +1,17 @@
 import eyg/interpreter/cast
 import gleam/http/request.{type Request}
+import gleam/uri
 import touch_grass/abort
 import touch_grass/copy
 import touch_grass/decode_json
 import touch_grass/download
 import touch_grass/fetch
+import touch_grass/flip
 import touch_grass/interface.{type Interface, Interface}
 import touch_grass/paste
 import touch_grass/print
+import touch_grass/prompt
+import touch_grass/visit
 
 pub fn abort() -> Interface(String, a, b) {
   Interface(abort.label, abort.lift(), abort.lower(), abort.decode)
@@ -39,6 +43,10 @@ pub fn fetch() -> Interface(Request(BitArray), a, b) {
   Interface(fetch.label, fetch.lift(), fetch.lower(), fetch.decode)
 }
 
+pub fn flip() -> Interface(Nil, a, b) {
+  Interface(flip.label, flip.lift(), flip.lower(), flip.decode)
+}
+
 pub fn paste() -> Interface(Nil, a, b) {
   Interface(paste.label, paste.lift(), paste.lower(), paste.decode)
 }
@@ -47,6 +55,14 @@ pub fn print() -> Interface(String, a, b) {
   Interface(print.label, print.lift(), print.lower(), print.decode)
 }
 
+pub fn prompt() -> Interface(String, a, b) {
+  Interface(prompt.label, prompt.lift(), prompt.lower(), prompt.decode)
+}
+
+pub fn visit() -> Interface(uri.Uri, a, b) {
+  Interface(visit.label, visit.lift(), visit.lower(), visit.decode)
+}
+
 pub fn map(interface: Interface(t, a, b), f: fn(t) -> u) -> Interface(u, a, b) {
   let Interface(decode:, ..) = interface
   let decode = cast.map(decode, f)

packages/touch_grass/src/touch_grass/flip.gleam

@@ -0,0 +1,21 @@
+import eyg/analysis/type_/isomorphic as t
+import eyg/interpreter/cast
+import gleam/int
+
+pub const label = "Flip"
+
+pub fn lift() {
+  t.unit
+}
+
+pub fn lower() {
+  t.boolean
+}
+
+pub fn decode(input) {
+  cast.as_unit(input, Nil)
+}
+
+pub fn sync() {
+  int.random(2) |> int.is_even
+}

packages/touch_grass/src/touch_grass/prompt.gleam

@@ -0,0 +1,16 @@
+import eyg/analysis/type_/isomorphic as t
+import eyg/interpreter/cast
+
+pub const label = "Prompt"
+
+pub fn lift() {
+  t.String
+}
+
+pub fn lower() {
+  t.result(t.String, t.unit)
+}
+
+pub fn decode(lift) {
+  cast.as_string(lift)
+}

packages/touch_grass/src/touch_grass/random.gleam

@@ -0,0 +1,26 @@
+import eyg/analysis/type_/isomorphic as t
+import eyg/interpreter/cast
+import eyg/interpreter/value as v
+import gleam/int
+
+pub const l = "Random"
+
+pub fn lift() {
+  t.Integer
+}
+
+pub fn lower() {
+  t.Integer
+}
+
+pub fn decode(lift) {
+  cast.as_integer(lift)
+}
+
+pub fn encode(number) {
+  v.Integer(number)
+}
+
+pub fn sync(max) {
+  int.random(max)
+}

packages/touch_grass/src/touch_grass/uri.gleam

@@ -0,0 +1,86 @@
+import eyg/analysis/type_/binding
+import eyg/analysis/type_/isomorphic as t
+import eyg/interpreter/break
+import eyg/interpreter/cast
+import eyg/interpreter/value as v
+import gleam/http as gleam_http
+import gleam/option.{None, Some}
+import gleam/result.{try}
+import gleam/uri.{Uri}
+import touch_grass/http
+
+pub fn uri() -> binding.Mono {
+  t.record([
+    #("scheme", http.scheme()),
+    // host + port = authority
+    #("host", t.String),
+    #("port", t.option(t.String)),
+    // path can be empty
+    #("path", t.String),
+    #("query", t.key_value_list(t.String)),
+  ])
+}
+
+pub fn uri_to_gleam(url: v.Value(a, b)) -> Result(uri.Uri, break.Reason(a, b)) {
+  use scheme <- try(cast.field("scheme", http.scheme_to_gleam, url))
+  use host <- try(cast.field("host", cast.as_string, url))
+  use port <- try(cast.field("port", cast.as_option(_, cast.as_integer), url))
+  use path <- try(cast.field("path", cast.as_string, url))
+  use query <- try(cast.field(
+    "query",
+    cast.as_list_of(_, fn(item) {
+      use key <- try(cast.field("key", cast.as_string, item))
+      use value <- try(cast.field("value", cast.as_string, item))
+      Ok(#(key, value))
+    }),
+    url,
+  ))
+  let query = uri.query_to_string(query)
+  Ok(Uri(
+    scheme: Some(gleam_http.scheme_to_string(scheme)),
+    userinfo: None,
+    host: Some(host),
+    port:,
+    path:,
+    query: Some(query),
+    fragment: None,
+  ))
+}
+// We shouldn't have the error cases, maybe touch grass needs a version of a more constrained uri to the encoding
+// pub fn url_to_eyg(url: uri.Uri) {
+//   case url {
+//     Uri(scheme: Some(scheme), host: Some(host), port:, path:, query:, ..) -> {
+//       case gleam_http.scheme_from_string(scheme) {
+//         Ok(scheme) -> {
+//           let query = option.unwrap(query, "")
+//           let query = uri.parse_query(query) |> result.unwrap([])
+//           v.Record(
+//             dict.from_list([
+//               #("scheme", http.scheme_to_eyg(scheme)),
+//               #("host", v.String(host)),
+//               #("port", v.option(port, v.Integer)),
+//               #("path", v.String(path)),
+//               #(
+//                 "query",
+//                 v.LinkedList(
+//                   list.map(query, fn(pair) {
+//                     let #(key, value) = pair
+//                     v.Record(
+//                       dict.from_list([
+//                         #("key", v.String(key)),
+//                         #("value", v.String(value)),
+//                       ]),
+//                     )
+//                   }),
+//                 ),
+//               ),
+//             ]),
+//           )
+//           |> v.ok()
+//         }
+//         Error(_) -> v.error(v.String("invalid scheme"))
+//       }
+//     }
+//     _ -> v.error(v.String("invalid url"))
+//   }
+// }

packages/touch_grass/src/touch_grass/visit.gleam

@@ -0,0 +1,22 @@
+import eyg/analysis/type_/isomorphic as t
+import eyg/interpreter/value as v
+import touch_grass/uri
+
+pub const label = "Visit"
+
+pub fn lift() {
+  t.String
+}
+
+pub fn lower() {
+  t.result(t.unit, t.String)
+}
+
+pub const decode = uri.uri_to_gleam
+
+pub fn encode(result) {
+  case result {
+    Ok(Nil) -> v.ok(v.unit())
+    Error(reason) -> v.error(v.String(reason))
+  }
+}

packages/website/src/website/harness/browser/fetch.gleam

@@ -1,24 +1,11 @@
 // Harness components merge type and runtime so cannot be put in either of those libraries
-import eyg/analysis/type_/isomorphic as t
 import eyg/interpreter/value as v
 import gleam/fetch as gfetch
 import gleam/javascript/promise
 import gleam/result
 import gleam/string
 import touch_grass/fetch
 
-pub const l = "Fetch"
-
-pub fn lift() {
-  todo
-  // http.request()
-}
-
-pub fn lower() {
-  todo
-  // t.result(http.response(), t.String)
-}
-
 pub fn run(request) {
   promise.map(do(request), fn(result) {
     result