fogus

(def mvec #(vec (map % %&)))

(mvec #(* % %) 1 2 3 4 5)
(mvec #(.toUpperCase %) "test")

;; The original doesn't return vectors -- it returns lazy seqs

fogus

(defmacro defunits-of [quantity base-unit & units]
  (let [magnitude (gensym)
	unit (gensym)
	conversions (apply hash-map base-unit 1 units)]
    `(defmacro ~(symbol (str "unit-of-" quantity))
       [~magnitude ~unit]
       `(* ~~magnitude 
	   ~(relative-units ~unit ~conversions)))))

fogus

;   Copyright (c) Rich Hickey. All rights reserved.
;   The use and distribution terms for this software are covered by the
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   which can be found in the file epl-v10.html at the root of this distribution.
;   By using this software in any fashion, you are agreeing to be bound by
;   the terms of this license.
;   You must not remove this notice, or any other, from this software.

(set! *warn-on-reflection* true)

fogus

#!/usr/bin/env python

import sys
import types
import operator

class Runtime:
    def __init__(self, env={}, stack=[]):
        self.env = {
            # Primitive words, not an impressive base but it works

fogus

(ns com.snowtide.clojure.memoize)

(defn- mutable-memoize
  [f #^java.util.Map map]
  (fn [& args]
    (if-let [e (find map args)]
      (val e)
      (let [ret (apply f args)]
        (.put map args ret)
        ret))))

fogus

(defsyntax-rules plet
  (plet [& var rhs] & body)
  ((fn [& var] & body) & rhs))

(plet [a 1 b 2] (+ a b)) ;=> 3

;;; Implementation of defsyntax-rules
; Using defmacro:
(defmacro defsyntax-rules
  [name & rt-pairs]

fogus

;;; Almost complete opinionated defn implementation
;;; Does not put the arg vector on the metadata
(defsyntax-class distinct-argument-vector []
  "distinct argument vector"
  []
  [var ...]
  :fail-when (check-duplicate (syntax (var ...))) "duplicate binding form")

(defsyntax-class docstring []
  "docstring"

fogus

class DynamicImpl(x: AnyRef) extends Dynamic {
  def _select_(name: String): DynamicImpl = {
    new DynamicImpl(x.getClass.getMethod(name).invoke(x))
  }
  def _invoke_(name: String)(args: Any*) = {
    new DynamicImpl(x.getClass.getMethod(name, args.map(_.asInstanceOf[AnyRef].getClass) : _*).invoke(x, args.map(_.asInstanceOf[AnyRef]) : _*))
  }
  override def typed[T] = x.asInstanceOf[T]
  override def toString = "Dynamic(" + x.toString + ")"
}

fogus

#!/usr/bin/env TEST=1 tclsh
# Lexical scoping in Tcl

proc let {block args} {
  try {
    set captured_vars [uplevel [list capture [block args]]]
    set all_var_names [uplevel {info vars}]
    
    foreach var [block args] value $args {
      uplevel [list catch [list unset $var]]

fogus

{-# LANGUAGE OverloadedStrings #-}

{- To Run:
   Load in ghci
   :set -XOverloadedStrings (for convenience)
   Execute repl expr -}

import Control.Applicative
import Data.Attoparsec hiding (Result)
import Data.Attoparsec.Char8 (char8, isDigit_w8, isSpace_w8)