{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.List.Singletons.Internal.Disambiguation
-- Copyright   :  (C) 2016 Richard Eisenberg
-- License     :  BSD-style (see LICENSE)
-- Maintainer  :  Ryan Scott
-- Stability   :  experimental
-- Portability :  non-portable
--
-- Renames a bunch of List functions because singletons can't support qualified
-- names. :(
--
----------------------------------------------------------------------------

module Data.List.Singletons.Internal.Disambiguation where

import Data.Eq.Singletons
import Data.List ( foldl', inits, insert, intersperse, isPrefixOf
                 , nubBy, partition, sort, sortBy, tails, transpose )
import Data.List.Singletons.Internal
import Data.Ord.Singletons
import Data.Singletons.Base.Instances
import Data.Singletons.TH
import GHC.Base.Singletons
import GHC.Num.Singletons
import GHC.TypeLits

-- singletons doesn't support qualified names :(
$(singletons [d|
  listlast :: [a] -> a
  listlast = last

  listinit :: [a] -> [a]
  listinit = init

  listsort :: Ord a => [a] -> [a]
  listsort = sort

  listinits :: [a] -> [[a]]
  listinits = inits

  listtails :: [a] -> [[a]]
  listtails = tails

  listinsert :: Ord a => a -> [a] -> [a]
  listinsert = insert

  listscanl :: (b -> a -> b) -> b -> [a] -> [b]
  listscanl = scanl

  listscanr :: (a -> b -> b) -> b -> [a] -> [b]
  listscanr = scanr

  listscanr1 :: (a -> a -> a) -> [a] -> [a]
  listscanr1 = scanr1

  listintersperse :: a -> [a] -> [a]
  listintersperse = intersperse

  listreverse :: [a] -> [a]
  listreverse = reverse

  listtakeWhile :: (a -> Bool) -> [a] -> [a]
  listtakeWhile = takeWhile

  listdropWhile :: (a -> Bool) -> [a] -> [a]
  listdropWhile = dropWhile

  listspan :: (a -> Bool) -> [a] -> ([a], [a])
  listspan = span

  listfilter :: (a -> Bool) -> [a] -> [a]
  listfilter = filter

  listpartition :: (a -> Bool) -> [a] -> ([a], [a])
  listpartition = partition

  listsortBy :: (a -> a -> Ordering) -> [a] -> [a]
  listsortBy = sortBy

  listisPrefixOf :: Eq a => [a] -> [a] -> Bool
  listisPrefixOf = isPrefixOf

  listzip :: [a] -> [b] -> [(a, b)]
  listzip = zip

  listzipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
  listzipWith = zipWith

  listnubBy :: (a -> a -> Bool) -> [a] -> [a]
  listnubBy = nubBy

  listtranspose :: [[a]] -> [[a]]
  listtranspose = transpose

  listunzip :: [(a,b)] -> ([a],[b])
  listunzip = unzip

  listmap :: (a -> b) -> [a] -> [b]
  listmap = map

  listelem :: Eq a => a -> [a] -> Bool
  listelem = elem

  listfoldl :: (b -> a -> b) -> b -> [a] -> b
  listfoldl = foldl

  listfoldl' :: (b -> a -> b) -> b -> [a] -> b
  listfoldl' = foldl'

  listfoldl1 :: (a -> a -> a) -> [a] -> a
  listfoldl1 = foldl1

  listfoldr :: (a -> b -> b) -> b -> [a] -> b
  listfoldr = foldr

  listfoldr1 :: (a -> a -> a) -> [a] -> a
  listfoldr1 = foldr1

  listmaximum :: Ord a => [a] -> a
  listmaximum = maximum

  listminimum :: Ord a => [a] -> a
  listminimum = minimum

  listnull :: [a] -> Bool
  listnull = null

  listproduct :: Num a => [a] -> a
  listproduct = product

  listsum :: Num a => [a] -> a
  listsum = sum
  |])

$(singletonsOnly [d|
  listtake :: Natural -> [a] -> [a]
  listtake = take

  listdrop :: Natural -> [a] -> [a]
  listdrop = drop

  listsplitAt :: Natural -> [a] -> ([a], [a])
  listsplitAt = splitAt

  listindex :: [a] -> Natural -> a
  listindex = (!!)

  listlength :: [a] -> Nat
  listlength = length
  |])

listtake :: Natural -> [a] -> [a]
listtake = undefined

listdrop :: Natural -> [a] -> [a]
listdrop = undefined

listsplitAt :: Natural -> [a] -> ([a], [a])
listsplitAt = undefined

listindex :: [a] -> Natural -> a
listindex = undefined

listlength :: [a] -> Nat
listlength = undefined