liarokapisv

select  RV.name, MV.title, RT.stars, RT.ratingDate 
from (select * from Reviewer) as RV join 
     (select * from Movie) as MV join
		 (select * from Rating) as RT on
		 (RV.rId = RT.rId and RT.mId = MV.mId)
order by RV.name asc, MV.title asc, RT.stars asc

liarokapisv

import Data.Singletons.Decide                                                                                                                                                                                       
import Data.Singletons.TH                                                                                                                                                                                           
import Data.Kind                                                                                                                                                                                                    
                                                                                                                                                                                                                    
                                                                                                                                                                            

liarokapisv

module Danac.Parser

import Danac.Lexer
import Text.Lexer
import Text.Parser

data SParser : Type -> Type -> Bool -> Type -> Type where
  MkSParser : (s -> Grammar t c (a, s)) -> SParser s t c a

Functor (SParser s t b) where

liarokapisv

module Test

import Text.Lexer
import Text.Parser


data Token : Type where
  AddOp : Token
  MulOp : Token
  IntConst : Token

liarokapisv

module Test                                                                                                                                                                                                         
                                                                                                                                                                                                                    
record Ann where                                                                                                                                                                                                    
  constructor MkAnn                                                                                                                                                                                                 
  ann1 : Type                                                                                                                                                               

liarokapisv

module Test

%default total

data Box : Type -> Type where
  MkBox : t -> Box t
   
data Test : Type where
  T1 : Test
  T2 : Box Test -> Test

liarokapisv

  mutual
  
  renameFuncCall : AnnFuncCall ParserAnn -> Renamer (AnnFuncCall RenamerAnn)
  renameFuncCall ((MkFuncCall x xs) .+. y) = [| [| MkFuncCall (renameIdentifier Func x) 
                                                     (traverse renameExpr xs) |] .+. [|y|] |]

  renameExpr : AnnExpr ParserAnn -> Renamer (AnnExpr RenamerAnn)
  renameExpr ((IntConst x) .+. y) = [| [| IntConst (renameIntConst x) |] .+. [|y|] |]
  renameExpr ((CharConst x) .+. y) = [| [| CharConst (renameCharConst x) |] .+. [|y|] |]
  renameExpr ((Lvalue x) .+. y) = [| [| Lvalue (renameLvalue x) |] .+. [|y|] |]

liarokapisv

data A
data A'

data B
data B'

data C
data C'

data ExtraX

liarokapisv

import game.PlayerModel;
import game.PlayerView;
import game.Player;
import game.GameState;
import java.util.Map;


public class PlayerController
{
  public class PlayerController(Map<Player, PlayerModel> modelMap, Map<Player, PlayerView> viewMap)

liarokapisv

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}

import Data.Functor.Foldable
import Data.Functor.Foldable.TH