tried storing data in CuArray. Weird type error is happening

package/src/ExpressionProcessing.jl

@@ -5,22 +5,24 @@ export replace_variables!
 export expr_to_postfix
 export SymbolTable64
 export PostfixType
+export Operator, Add, Subtract, Multiply, Divide, Power, Abs, Log, Exp, Sqrt
 
+@enum Operator Add=1 Subtract=2 Multiply=3 Divide=4 Power=5 Abs=6 Log=7 Exp=8 Sqrt=9
 const SymbolTable64 = Dict{Tuple{Expr, Symbol},Float64}
-const PostfixType = Array{Union{Float64,String},1}
+const PostfixType = Vector{Union{Float64,Operator,Symbol}}
 
 # Maybe switch from Array{String} to Array{Union{Float64, Symbol}}?
 function expr_to_postfix(expr::Expr)::PostfixType
 	postfix = PostfixType()
-	operator = String(expr.args[1])
+	operator = get_operator(expr.args[1])
 
 	# push!(postfix, expr.args[2], expr.args[3], operator)
 	for j in 2:length(expr.args)
 		arg = expr.args[j]
 		if typeof(arg) === Expr
 			append!(postfix, expr_to_postfix(arg))
-		elseif typeof(arg) === Symbol
-			push!(postfix, String(arg))
+		elseif typeof(arg) === Symbol # variables/parameters
+			push!(postfix, arg)
 		else
 			push!(postfix, convert(Float64, arg))
 		end
@@ -76,4 +78,26 @@ function fill_symtable!(expr::Expr, symtable::SymbolTable64, values::Vector{Floa
 	end
 end
 
+function get_operator(op::Symbol)::Operator
+	if op == :+
+		return Add
+	elseif op == :-
+		return Subtract
+	elseif op == :*
+		return Multiply
+	elseif op == :/
+		return Divide
+	elseif op == :^
+		return Power
+	elseif op == :abs
+		return Abs
+	elseif op == :log
+		return Log
+	elseif op == :exp
+		return Exp
+	elseif op == :sqrt
+		return Sqrt
+	end
+end
+
 end

package/src/Interpreter.jl

@@ -1,34 +1,35 @@
 module Interpreter
 using CUDA
 include("ExpressionProcessing.jl")
+using .ExpressionProcessing: PostfixType, Add, Subtract, Operator
 
+export Interpret
 export CudaTest
 
-@enum Operators Add=1 Subtract=2 Multiply=3 Division=4 Power=5 Abs=6 Log=7 Exp=8 Sqrt=9
-
 function CudaTest()
 	N = 2^20
 	x = CUDA.fill(1.0f0, N)
 	y = CUDA.fill(2.0f0, N)
 
-	kernelAdd = @cuda launch=false InterpretExplicit!(Add, x, y)
+	kernelAdd = @cuda launch=false InterpretExplicit!(ExpressionProcessing.Add, x, y)
+	# kernelAdd = @cuda launch=false InterpretExplicit!(Add, x, y, reference)
 	config = launch_configuration(kernelAdd.fun)
 	threads = min(length(y), config.threads)
 	blocks = cld(length(y), threads)
 	
 	kernelAdd(Add, x, y; threads, blocks)
-	println(y[1])
+	# println(y[1])
 	# @test all(Array(y) .== 3.0f0)
 	
-	kernelSubtract = @cuda launch=false InterpretExplicit!(Subtract, x, y)
+	kernelSubtract = @cuda launch=false InterpretExplicit!(ExpressionProcessing.Subtract, x, y)
 	configSub = launch_configuration(kernelSubtract.fun)
 	threadsSub = min(length(y), configSub.threads)
 	blocksSub = cld(length(y), threadsSub)
 	CUDA.fill!(y, 2.0f0)
 	
-	kernelSubtract(Subtract, x, y; threadsSub, blocksSub)
+	# kernelSubtract(Subtract, x, y; threadsSub, blocksSub)
 	# @test all(Array(y) .== -1.0f0)
-	println(y[1])
+	# println(y[1])
 end
 
 "Interprets the given expressions with the values provided.
@@ -42,22 +43,27 @@ function Interpret(expressions::Vector{ExpressionProcessing.PostfixType}, variab
 	#      create CUDA array and fill it with the expressions, variables and parameters
 	#      calculate needed number of threads, probably based off of the number of expressions, so I can ensure each warp takes the same execution path
 	#      Start the kernel
+	cudaExprs = Vector{CuArray{ExpressionProcessing.PostfixType}}(undef, length(expressions))
+	for i in eachindex(expressions)
+		push!(cudaExprs, CuArray(expressions[i]))
+	end
+	# cudaExprs = CuArray(copy(expressions))
 end
 
 
 # Kernel
-function InterpretExplicit!(op::Operators, x, y)
+function InterpretExplicit!(op::Operator, x, y)
 	index = (blockIdx().x - 1) * blockDim().x + threadIdx().x
 	stride = gridDim().x * blockDim().x
 
 	if op == Add
-		@cuprintln("Performing Addition") # Will only be displayed when the GPU is synchronized
+		# @cuprintln("Performing Addition") # Will only be displayed when the GPU is synchronized
 		for i = index:stride:length(y)
 			@inbounds y[i] += x[i]
 		end
 		return
 	elseif op == Subtract
-		@cuprintln("Performing Subtraction") # Will only be displayed when the GPU is synchronized
+		# @cuprintln("Performing Subtraction") # Will only be displayed when the GPU is synchronized
 		for i = index:stride:length(y)
 			@inbounds y[i] -= x[i]
 		end