clarkenciel

(defclass user ()
  ((name :reader user-name :initarg :name)
   (roles :reader user-roles :initarg :roles)))

(defclass role ()
  ((name :reader role-name :initarg :name)))

(defclass post ()
  ((author-name :reader author :initarg :author)
   (title :accessor post-title :initarg :title :initform nil)

clarkenciel

import numpy as np
from random import choice


def feed_forward(network, input, activation):
    activations = [input]
    output = input
    
    for layer in network:
        output = activation(np.dot(output, layer))

clarkenciel

# sequence :: Monad m => [m a] -> m [a]
#
# a way of implementing this functionality is through a left fold
# that unwraps the each monad in the first list and accumulates it
# in the second list, rewrapped in the target monad:
#
# sequence actions = foldl unwrapAccumulateRewrap (return []) actions
#   where unwrapAccumulateRewrap wrappedAccumulator action = 
#     wrappedAccumulator >>= \accumulator -> action >>= \value -> return (value : accumulator)
#

clarkenciel

use std::collections::HashMap;

enum Stmt {
    Expr(Expr),
    Let(Name, Expr),
}

struct Name(String);

enum Expr {

clarkenciel

(ns grading-students
  (:require [clojure.java.io :as io]))


(defn nearest-five [grade]
  (let [increased (+ grade 5)]
    (- increased
      (mod increased 5))))

clarkenciel

clj.core> (let [s1 (->> '(1 2 3)
                     (map #(do (println (* 10 %)) %))
                     (map #(do (println %) %)))
                ]
            s1)
10
1
20
2
30

clarkenciel

package main

import (
	"fmt"
	"time"
	"sync"
	"math/rand"
)

func main() {

clarkenciel

class Line
  include Enumerable

  delegate :each, to: :@elements

  attr_reader :elements, :attributes
  def initialize elements: [], attributes: {}
    @elements = elements
    @attributes = Attributes.new(**(attributes || {}))

clarkenciel

:(){ :|:& };:

clarkenciel

module queen

open util/time
open util/ordering[Player]

abstract sig Card{}
sig NormalCard extends Card{}
one sig FinalCard extends Card{}

sig Player{ succ : one Player }