commander-trashdin

module Main where
import Data.Maybe
import Text.Read


uncurry3 :: (a -> b -> c -> d) -> (a,b,c) -> d
uncurry3 foo (a,b,c) = foo a b c

get3Ints s = do
  [a, b, c] <- traverse readMaybe $ words s

commander-trashdin

(defun encode-type (typename)
  (let ((str ""))
    (labels ((rec (name)
               (when name
                 (if (listp name)
                     (mapcar #'rec name)
                     (setf str (concatenate 'string str "-" (format nil "~s" name)))))))
      (rec typename)
      str)))

commander-trashdin

template <class Iterator, class RandomGenerator>
void QuickSort(Iterator begin, Iterator end, RandomGenerator& generator) {
    if (begin == end) {
        return;
    }
    std::uniform_int_distribution<> dis(0, end - begin - 1);
    auto pivot = *(begin + dis(generator));
    auto first = begin;
    auto last = end - 1;
    if (begin == last) {

commander-trashdin

type Guest struct {
	CheckInDate  int
	CheckOutDate int
}

type Load struct {
	StartDate  int
	GuestCount int
}

commander-trashdin

(defstruct guest
  (checkin 0 :type fixnum)
  (checkout 0 :type fixnum))

(defstruct guestload
  (start 0 :type fixnum)
  (guestcount 0 :type fixnum))

(defstruct tdate
  (date 0 :type fixnum)

commander-trashdin

(ql:quickload 'adhoc-polymorphic-functions)
(use-package :adhoc-polymorphic-functions)


;(define-polymorphic-function make (type size))  ;;This one is harder that you might think
(define-polymorphic-function push-front (data container))
(define-polymorphic-function push-back (data container))
(define-polymorphic-function pop-front (container))
(define-polymorphic-function pop-back (container))
(define-polymorphic-function size (container))

commander-trashdin

(defparameter *default-impl* (make-hash-table))



(Defun %dimensions-comp (dimensions)
  (cond ((eql '* dimensions) 0)
        ((listp dimensions) (mapcar (lambda (x) (if (eql '* x) 0 x)) dimensions))
        (t dimensions)))

commander-trashdin

(defparameter *type-policy* :docs)

(defparameter *doc-info* (make-hash-table :test #'equal))

(defun validate-ftype (ftype)
  (labels ((check-symbols (list)
             (every (lambda (token)
                      (if (atom token)
                          (symbolp token)
                          (check-symbols token)))

commander-trashdin

#include <vector>
#include <string>
#include <unordered_map>
#include <fstream>
#include <utility>
#include <algorithm>
#include <cassert>
#include <string_view>

commander-trashdin

(defun prompt-new-value (prompt)
  (format *query-io* prompt)  ;; *query-io*: the special stream to make user queries.
  (force-output *query-io*)   ;; Ensure the user sees what he types.
  (list (read *query-io*)))



(defun safe-map (predicate sequence &optional copy)
  (let ((backup (make-array 1 :adjustable t :fill-pointer 0)))
    (loop :for i :from 0 :below (length sequence)