EduardoRFS

[@@@ocaml.warning "-32"]

module Location = struct
  include Location

  let pp = print_loc
end

module Longident = struct
  include Longident

davesnx

.PHONY: help # Set default action to be help!

help:
	@echo "List of available make commands";
	@echo "";
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2}';
	@echo "";
	
# Add double ## comments on the same line as the dependencies and will be printed out when running help
# Don't add them if you don't want to appear on help!

piperswe

#!/bin/sh

# Required on macOS because cctools is marked as broken
export NIXPKGS_ALLOW_BROKEN=1
nix run -f image.nix -c push
docker run ghcr.io/piperswe/hello

jsiebern

module Store = {
  type action =
    | Increase
    | Decrease
    | SetUsername(string);
  type state = {
    count: int,
    username: string,
  };
  type storeBag = {

busypeoples

Phantom types in ReasonML

Introduction

"A phantom type is a parametrised type whose parameters do not all appear on the right-hand side of its definition..." Haskell Wiki, PhantomType

The following write-up is intended as an introduction into using phantom types in ReasonML.

Taking a look at the above definition from the Haskell wiki, it states that phantom types are parametrised types where not all parameters appear on the right-hand side. Let's try to see if we can implement a similar example as in said wiki.

busypeoples

/* Slaying a UI Anti Pattern in Reason */

type remoteData 'e 'a =
  | Nothing
  | Loading
  | Failure 'e
  | Success 'a;

type item = {
  userId: int,

jasim

type json = Js.Json.t;

let x: json = [%bs.raw {|{"a": [1, "hello", 2, {"b": {"c": [100,200, "d", [10,20,30]]}}]}|}];

let rec json_to_string json => {
  let array_to_string a => a |> Array.to_list |> String.concat ",";
  let emitObject o =>
    "{" ^
    {
      let emitKV (key, value) => key ^ ": " ^ json_to_string value;

swannodette

Code Splitting

NOTE: This gist uses the master branch of ClojureScript. Clone ClojureScript and from the checkout run ./script/bootstrap and ./script/uberjar. This will produce target/cljs.jar which you can use to follow this guide.

As client applications become larger it becomes desirable to load only the code actually required to run a particular logical screen. Previously ClojureScript :modules compiler option permitted such code splitting, but this feature only worked under :advanced compilation and users would still have to manage loading these splits. :modules also required manual

candera

# Update: This micro-blog is now also a guide on clojurescript.org: 
# http://clojurescript.org/guides/native-executables

# Hello! This is a micro-post about how to produce native executables
# from ClojureScript source. The basic idea is to produce a
# JavaScript file using the ClojureScript compiler, and then use a
# Node.js tool called nexe (https://github.com/jaredallard/nexe) to
# compile that into an executable. The resulting file can be run
# without requiring a node install on the target machine, which can
# be handy.

Peeja

;; Re-render when Figwheel reloads.
(gevents/listen js/document.body
                "figwheel.js-reload"
                (fn []
                  (let [root-component (om-next/app-root (compassus/get-reconciler a))]
                    (letfn [(js-vals [o]
                              (map #(aget o %) (js-keys o)))
                            ;; Finds the children of a React internal instance of a component.
                            ;; That could be a single _renderedComponent or several
                            ;; _renderedChildren.